Mini Las Vegas Sphere

Project group picture

#Libraries Needed
import board
import neopixel
from time import sleep
import RPi.GPIO as GPIO
import time
import subprocess
import pygame,pigame
from pygame.locals import *
import sys
import os
import serial



######################### PiTFT Screen Setup Below ###########################

#Color Setup
WHITE = (255,255,255)
BLACK = (0, 0, 0)

#PiTFT Screen Initialization
os.putenv('SDL_VIDEODRV','fbcon')
os.putenv('SDL_FBDEV', '/dev/fb1')
os.putenv('SDL_MOUSEDRV','dummy')
os.putenv('SDL_MOUSEDEV','/dev/null')
os.putenv('DISPLAY','')

#intialize the pygame 
pygame.init()
#connect pygame with the piTFT 
pitft = pigame.PiTft()

#set the display to size of the piTFT 
lcd = pygame.display.set_mode((320, 240))
lcd.fill((0,0,0))
#always need to update display after a change to have it show up 
pygame.display.update()

size = width, height = 320, 240 #size of window
screen = pygame.display.set_mode(size) #display screen size



######################### PiTFT Screen Menu Setup Below ###########################

font_big = pygame.font.Font(None, 50) #set font size to be big
font_medium = pygame.font.Font(None, 35) #set font size to be medium
font_small = pygame.font.Font(None, 25) #set font size to be small   

# set coordinates of where each image will be stationed
labels = {'Please Choose An Image' : (160, 25), 'Earth' : (40, 110), 'Soccer': (120, 110), 'Tennis' : (200, 110), 'Laugh' : (280, 110), 'Potato' : (40,210) , 'Cornell': (120, 210), 'Rpi' : (200,210), 'Alien' : (280,210)}

#Earth
earth = pygame.image.load("/home/pi/finalproj/menuimages/Earth.jpg").convert_alpha() #load the image and change scale
earth = pygame.transform.scale(earth, (40,40)) #further change the scale before getting the rectangle 
earthrect = earth.get_rect()
#Soccer
soccer = pygame.image.load("/home/pi/finalproj/menuimages/Soccer.jpg").convert_alpha() #load the image and change scale
soccer = pygame.transform.scale(soccer, (40,40)) #further change the scale before getting the rectangle 
soccerrect = soccer.get_rect()
#TennisBall
tennis = pygame.image.load("/home/pi/finalproj/menuimages/TennisBall.jpg").convert_alpha() #load the image and change scale
tennis = pygame.transform.scale(tennis, (40,40)) #further change the scale before getting the rectangle 
tennisrect = tennis.get_rect()
#Laugh-Emoji
laugh = pygame.image.load("/home/pi/finalproj/menuimages/Laugh.jpg").convert_alpha() #load the image and change scale
laugh = pygame.transform.scale(laugh, (40,40)) #further change the scale before getting the rectangle 
laughrect = laugh.get_rect()
#Moon
potato = pygame.image.load("/home/pi/finalproj/menuimages/Potato.jpg").convert_alpha() #load the image and change scale
potato = pygame.transform.scale(potato, (40,40)) #further change the scale before getting the rectangle 
potatorect = potato.get_rect()
#Cornell
cornell = pygame.image.load("/home/pi/finalproj/menuimages/Cornell.jpg").convert_alpha() #load the image and change scale
cornell = pygame.transform.scale(cornell, (40,40)) #further change the scale before getting the rectangle 
cornellrect = cornell.get_rect()
#Rpi
rpi = pygame.image.load("/home/pi/finalproj/menuimages/Rpi.png").convert_alpha() #load the image and change scale
rpi = pygame.transform.scale(rpi, (40,40)) #further change the scale before getting the rectangle 
rpirect = rpi.get_rect()
#Toy
toy = pygame.image.load("/home/pi/finalproj/menuimages/Alien.jpg").convert_alpha() #load the image and change scale
toy = pygame.transform.scale(toy, (40,40)) #further change the scale before getting the rectangle 
toyrect = toy.get_rect()

#update the screen 
pygame.display.update()



######################### GPIO Pin/Button and Boolean Variables Setup Below ###########################

#bailout button 
def GPIO27_callback(channel):
    global code_run
    code_run = False

GPIO.setwarnings(False) #disables warnings
GPIO.setmode(GPIO.BCM)
GPIO.setup(27, GPIO.IN, pull_up_down=GPIO.PUD_UP) #set quit button as an GPIO input
GPIO.add_event_detect(27, GPIO.FALLING, callback=GPIO27_callback, bouncetime = 300)
time_limit = 600 #timer limit
fps= 24 #frame rate of the screen
my_clock = pygame.time.Clock()
starttime = time.time()
code_run = True

#image boolean values
earthrun = False
soccerrun = False
tennisrun = False
laughrun = False
potatorun = False
cornellrun = False
rpirun = False
toyrun = False


################################### Main Loop Below ###################################

try:
    while code_run:
        #UART initialization
        #/dev/ttyUSB0 the USB(top right) serial connection 
        ser = serial.Serial('/dev/ttyUSB0', 9600, timeout =1) #9600 baud rate of ESP32
        ser.reset_input_buffer() #resets serial buffer, helps flushes out noise and previous messages
        
        now = time.time() #keeps track of time
        elapsed_time = now-starttime
        if (elapsed_time > time_limit):
            code_run = False
        time.sleep(0.2)
        pitft.update() #update the screen 

        for event in pygame.event.get(): #event polling
            if(event.type is MOUSEBUTTONDOWN):
                x,y = pygame.mouse.get_pos()
                #print(x,y)
            elif(event.type is MOUSEBUTTONUP):
                x,y = pygame.mouse.get_pos()
                if y > 50 and y < 90 and x > 20 and x < 60: #Earth image pressed
                    print("Earth")
                    earthrun = True
                    soccerrun = False
                    tennisrun = False
                    laughrun = False
                    potatorun = False
                    cornellrun = False
                    rpirun = False
                    toyrun = False
                    string = "earth" + "\n" #"\n" indicates line separation
                    string = string.encode('utf_8') #UART encoder, the default
                    ser.write(string) #sending to ESP32 via UART
                    line = ser.readline().decode('utf_8').rstrip() #strips recieved message
                    print("received: ", line)
                elif y > 50 and y < 90 and x > 100 and x < 140:#Soccer ball image pressed
                    print("Soccer") 
                    earthrun = False
                    soccerrun = True
                    tennisrun = False
                    laughrun = False
                    potatorun = False
                    cornellrun = False
                    rpirun = False
                    toyrun = False
                    string = "soccer" + "\n" #"\n" indicates line separation
                    string = string.encode('utf_8')#UART encoder, the default
                    ser.write(string) #sending to ESP32 via UART
                    line = ser.readline().decode('utf_8').rstrip() #strips recieved message
                    print("received: ", line)
                elif y > 50 and y < 90 and x > 180 and x < 220: #Tennis Ball image pressed
                    print("Tennis Ball")
                    earthrun = False
                    soccerrun = False
                    tennisrun = True
                    laughrun = False
                    potatorun = False
                    cornellrun = False
                    rpirun = False
                    toyrun = False
                    string = "tennis ball" + "\n" #"\n" indicates line separation
                    string = string.encode('utf_8')#UART encoder, the default
                    ser.write(string) #sending to ESP32 via UART
                    line = ser.readline().decode('utf_8').rstrip() #strips recieved message
                    print("received: ", line)
                elif y > 50 and y < 90 and x > 260 and x < 300: #Laughing emoji image pressed
                    print("Laughing") 
                    earthrun = False
                    soccerrun = False
                    tennisrun = False
                    laughrun = True
                    potatorun = False
                    cornellrun = False
                    rpirun = False
                    toyrun = False
                    string = "laughing" + "\n" #"\n" indicates line separation
                    string = string.encode('utf_8')#UART encoder, the default
                    ser.write(string) #sending to ESP32 via UART
                    line = ser.readline().decode('utf_8').rstrip() #strips recieved message
                    print("received: ", line)
                elif y > 150 and y < 190 and x > 20 and x < 60: #Mr.Potato Head image pressed
                    print("Potato")
                    earthrun = False
                    soccerrun = False
                    tennisrun = False
                    laughrun = False
                    potatorun = True
                    cornellrun = False
                    rpirun = False
                    toyrun = False
                    string = "potato" + "\n" #"\n" indicates line separation
                    string = string.encode('utf_8')#UART encoder, the default
                    ser.write(string) #sending to ESP32 via UART
                    line = ser.readline().decode('utf_8').rstrip() #strips recieved message
                    print("received: ", line)
                elif y > 150 and y < 190 and x > 100 and x < 140: #Cornell Logo image pressed
                    print("Cornell")
                    earthrun = False
                    soccerrun = False
                    tennisrun = False
                    laughrun = False
                    potatorun = False
                    cornellrun = True
                    rpirun = False
                    toyrun = False
                    string = "cornell" + "\n" #"\n" indicates line separation
                    string = string.encode('utf_8')#UART encoder, the default
                    ser.write(string) #sending to ESP32 via UART
                    line = ser.readline().decode('utf_8').rstrip() #strips recieved message
                    print("received: ", line)
                elif y > 150 and y < 190 and x > 180 and x < 220: #Rpi image pressed
                    print("Rpi")
                    earthrun = False
                    soccerrun = False
                    tennisrun = False
                    laughrun = False
                    potatorun = False
                    cornellrun = False
                    rpirun = True
                    toyrun = False
                    string = "rpi" + "\n" #"\n" indicates line separation
                    string = string.encode('utf_8')#UART encoder, the default
                    ser.write(string) #sending to ESP32 via UART
                    line = ser.readline().decode('utf_8').rstrip() #strips recieved message
                    print("received: ", line)
                elif y > 150 and y < 190 and x > 260 and x < 300: #Alien image pressed
                    print("Alien")
                    earthrun = False
                    soccerrun = False
                    tennisrun = False
                    laughrun = False
                    potatorun = False
                    cornellrun = False
                    rpirun = False
                    toyrun = True
                    string = "toy" + "\n" #"\n" indicates line separation
                    string = string.encode('utf_8')#UART encoder, the default
                    ser.write(string) #sending to ESP32 via UART
                    line = ser.readline().decode('utf_8').rstrip() #strips recieved message
                    print("received: ", line)

        #Combine picture surface with workspace surface
        screen.blit(earth, (20,50)) #Earth
        screen.blit(soccer,(100,50)) #soccer
        screen.blit(tennis, (180,50)) #Tennis Ball
        screen.blit(laugh, (260,50)) #Laughing Emoji
        screen.blit(potato, (20,150)) #potato
        screen.blit(cornell, (100,150)) #Death Star
        screen.blit(rpi, (180,150)) #rpi
        screen.blit(toy, (260,150)) #alien
        for k,v in labels.items():
            text_surface = font_small.render('%s'%k, True, WHITE)
            rect = text_surface.get_rect(center=v)
            lcd.blit(text_surface, rect) # need to combine the workspace
        pygame.display.flip()  #Display workspace on screen
    

except KeyboardInterrupt:
    pass
finally:
    del(pitft)
        
        

//Libraries needed
  #include <Adafruit_DotStar.h>
  #include <SPI.h>
  
  // Include each of the images These are generated using genMatr.py.
  #include "images/earth.h"
  #include "images/soccer.h" // soccer ball 
  #include "images/tennisballmapping.h"
  #include "images/laughing.h"
  #include "images/potato.h" // pacman 
  #include "images/Cornell.h" // cornell logo 
  #include "images/Rpi.h" // rpi logo 
  #include "images/toy.h" // gutetama
  
  
  //image struct 
  typedef struct _image_metadata {
    uint8_t* data;
    int columns;
    int rows;
  } image_metadata;
  
  
  #define MAKEIMAGE(_name, _columns, _rows) (image_metadata){ data: (uint8_t*)&_name[0], columns: _columns, rows: _rows, } //image setup
  
  #define NUM_IMAGES 8 //total current images
  image_metadata images[NUM_IMAGES] = {
    MAKEIMAGE(IMAGE_earth, IMAGE_COLUMNS_earth, IMAGE_ROWS_earth), // earth image
    MAKEIMAGE(IMAGE_soccer, IMAGE_COLUMNS_soccer, IMAGE_ROWS_soccer), // soccer image
    MAKEIMAGE(IMAGE_tennisballmapping, IMAGE_COLUMNS_tennisballmapping, IMAGE_ROWS_tennisballmapping), // tennis ball image
    MAKEIMAGE(IMAGE_laughing, IMAGE_COLUMNS_laughing, IMAGE_ROWS_laughing), // laughing emoji image
    MAKEIMAGE(IMAGE_potato, IMAGE_COLUMNS_potato, IMAGE_ROWS_potato), // Mr.Potato head image
    MAKEIMAGE(IMAGE_Cornell, IMAGE_COLUMNS_Cornell, IMAGE_ROWS_Cornell), // Cornell logo image
    MAKEIMAGE(IMAGE_Rpi, IMAGE_COLUMNS_Rpi, IMAGE_ROWS_Rpi), // Raspberry Pi logo image
    MAKEIMAGE(IMAGE_toy, IMAGE_COLUMNS_toy, IMAGE_ROWS_toy) // Alien triplets image
     
  };
  
  // Number of LEDs in the entire strip
  #define NUMPIXELS 72
  // ESP32 Data pin for the DotStar strip
  #define DATAPIN    14
  // Clock pin for the DotStar strip
  #define CLOCKPIN   32
  Adafruit_DotStar strip(NUMPIXELS, DATAPIN, CLOCKPIN, DOTSTAR_BGR);
  
  // Input pin for the Hall effect sensor
  #define HALLPIN  15
  
  
  // Initial LED strip brightness value
  #define BRIGHTNESS 20
  // Number of columns displayed in a single revolution
  #define NUM_COLUMNS 72
  
  // Time in microsecoonds after which a failed Hall effect detection turns off the LEDs
  #define IDLE_TIME 1000000 // (1 sec)
  // Alpha parameter for EWMA calculation of revolution time
  #define ALPHA 0.5
  // If defined, only show pattern on the front LED strip (rather than on both front and back)
  #define FRONT_STRIP_ONLY
  // If defined, flash red when the motor is spinning too fast to display all columns in one revolution
  #define WARN_IF_TOO_FAST
  // Static offset for shifting pixel display in X and Y dimensions
  #define X_SHIFT 0
  #define Y_SHIFT 0
  // Y-offset in pixels for back strip versus front strip
  #define BACK_OFFSET 3
  // Time in microseconds to trigger next longitudinal shift in the image
  #define ROTATE_INTERVAL 10000
  
  // Initialization of the variables needed 
  int started = 0;
  int cur_hall = 0;
  int cur_step = 0;
  int cur_x_offset = 0;
  uint32_t last_hall_time = 0;
  uint32_t last_rotate_time = 0;
  uint32_t last_clock_time = 0;
  uint32_t last_button_time = 0;
  uint32_t cycle_time = 0;
  uint32_t per_column_time = 0;
  uint32_t next_column_time = 0;
  
  int cur_image_index; // change index value with UART
  image_metadata *cur_image = &images[cur_image_index]; //current image pointer
  
  
  
  //******************************************************************************* Helper Functions Below **************************************************************************************//
  
  
  // Set all pixels to the given color.
  void setAll(uint32_t color) {
    for (int i = 0; i < NUMPIXELS; i++) { //lloops through the entire LED strip length
      strip.setPixelColor(i, color); // sets color of each pixel
    }
    strip.show(); // broadcasts pixel color
  }
  
  uint32_t get_color(int x, int y) { // gets Color from the image header file
    if (x < 0 || x > cur_image->columns-1) return 0x0; // not within the dedicated columns, return no color
    if (y < 0 || y > cur_image->rows-1) return 0x0; // not within dedicated row, return no color
    int index = (y * cur_image->columns * 3) + (x * 3); // takes apart array in triplet sets representing RGB
    uint8_t* p = (uint8_t*)&cur_image->data[index]; // pointer gets pixel value according to triplet sets
    uint32_t* pv = (uint32_t*)p; // pointer to the array
    uint32_t pixel = (*pv) & 0xffffff; // pixel value from pointer
    return pixel; 
  }
  
  void doPaint(uint32_t cur_time) { // paints and broadcasts LED colors
    if (cur_time < next_column_time) { //ring not spinning
      return; // exit function
    }
    
    int x = (cur_step - X_SHIFT + cur_x_offset) % NUM_COLUMNS; // x axis of our ring, based off of offsetted values which varies with motor
    int frontx = x; //front strip labeled
    int backx = (x + (NUM_COLUMNS/2)) % NUM_COLUMNS; // backstrip labeled and will start from the LED closest to the slip ring (LED[0])
  
    // Front strip.
    for (int i = 0; i < NUMPIXELS/2; i++) { //loops through half of the LED strip
      int y = (NUMPIXELS/2) - i;   // Swap y-axis of the front stip according to the array of colors from image header file
      strip.setPixelColor(i, get_color(frontx, y)); // uses library to set each pixel the color of the image array/header file
    }
  
    // Back strip.
    for (int i = NUMPIXELS/2; i < NUMPIXELS; i++) { //loops through half of the LED strip
      int y = i - (NUMPIXELS/2) + BACK_OFFSET; // Swap y-axis of the back strip according to the array of colors from image header file
      strip.setPixelColor(i, get_color(backx, y));
    }
  
    strip.show(); // displays the LED colors that are now done setting 
    cur_step++; //increases current step to allow new column of pixels to be read from image file
    next_column_time = cur_time + per_column_time; // next column time updated accordingly (can be affected by motor speeds, hall effect sensor depends on motor speed)
  }
  
  
  
  //******************************************************************* SetUp and Main Loop Function Below **************************************************************************************//
  
  
  void setup() {
    Serial.begin(9600); //UART baud rate, can be changed but Rpi side would need to be changed to match this value
    Serial.println("Initializing..."); // start up sequence
    
    pinMode(LED_BUILTIN, OUTPUT); // LED GPIO pin setup for ESP32 
    pinMode(HALLPIN, INPUT_PULLUP); // hall effect sensor GPIO pin setup for ESP32
    
    last_hall_time = micros(); // sets time in microseconds (10^-6)
    next_column_time = micros(); // sets time in microseconds (10^-6)
  
    strip.begin(); // final intialization of the LED strip
    strip.show(); // shows the LED strip color(in this case always begins with LEDs all turned off, as no color was set previously
    strip.setBrightness(BRIGHTNESS); // sets brightness of the LEDs to 20
  }
  
  
  void loop() { // constant loop 
    uint32_t cur_time = micros(); // current time in microseconds (10^-6)
    int hall = digitalRead(HALLPIN); // the hall pin value initially
  
    //UART BELOW
    if(Serial.available() >0) //constant polling of the Serial terminal
    {
      String data = Serial.readStringUntil('\n');//reading entire line sent from the Rpi
      Serial.print("You sent me: ");//retransmitting recevied message to notify the Rpi that message sent was successful
      Serial.println(data); //retransmitting received message
      if(data.equals("earth")) //different images sent from the Rpi --> default image is the Earth
      {
        cur_image_index = 0; //grab image from array of pre-made images
        Serial.println("cur_image_index =" + cur_image_index); //prints our image index as a placeholder 
      }
      if(data.equals("soccer")) //soccer ball image
      {
        cur_image_index = 1;
        Serial.println("cur_image_index =" + cur_image_index);
      }
      if(data.equals("tennis ball")) // tennis ball image
      {
        cur_image_index = 2;
        Serial.println("cur_image_index =" + cur_image_index);
      }
      if(data.equals("laughing")) // laughing emoji image
      {
        cur_image_index = 3;
        Serial.println("cur_image_index =" + cur_image_index);
      }
      if(data.equals("potato")) // Mr.Potato head image
      {
        cur_image_index = 4;
        Serial.println("cur_image_index =" + cur_image_index);
      }
      if(data.equals("cornell")) // Cornell logo image
      {
        cur_image_index = 5;
        Serial.println("cur_image_index =" + cur_image_index);
      }
      if(data.equals("rpi")) // Rpi logo image
      {
        cur_image_index = 6;
        Serial.println("cur_image_index =" + cur_image_index);
      }
      if(data.equals("toy")) // Alien Triplets from ToyStory image
      {
        cur_image_index = 7;
        Serial.println("cur_image_index =" + cur_image_index);
      }
      cur_image = &images[cur_image_index]; // sets the newly updated image from UART to the current image to display on the ring
    }
  
    if (hall == LOW && cur_hall == 1) { // the transition from high to low of the hall effect sensor
      if (cur_time - last_hall_time > 10000) {  // Debounce.     
        cur_hall = 0; // current hall value is low
        cur_step = 0; // Reset cycle of spinning
        // Estimates timing of the braodcasting of the LEDs to take into account of the irregularities of the motor spinning by conditioning on the hall effect sensor values
        cycle_time = (ALPHA * cycle_time) + ((1.0 - ALPHA) * (cur_time - last_hall_time)); //EWMA Calculation~:) uses a weighted estimate to generate a "accurate" prediction of cycle time
        per_column_time = (cycle_time / NUM_COLUMNS); // uses predicted cycle time to estimate column time
        next_column_time = cur_time - per_column_time; // uses predicted cycle time to estimate next column time
        last_hall_time = cur_time;
      
        #ifdef ROTATE_INTERVAL
        if (cur_time - last_rotate_time > ROTATE_INTERVAL) {
          last_rotate_time = cur_time;
        }
  #endif
      }
    } else if (hall == HIGH && cur_hall == 0) { // transition of 1 revolution
      cur_hall = 1; // updates cur_hall to be high as hall's digital read is HIGH
  #ifdef HALLDEBUG
      setAll(0x0); // debug when hall effect not sensed, turns off all LEDs
  #endif
    }
  #ifndef HALLDEBUG
    if (cur_time - last_hall_time < IDLE_TIME) { //when the hall effect sensor is detected within 1 second, need to display image
      doPaint(cur_time); // paints LEDs based on current time
    } else {
      setAll(0x0); // paints all LEDs to be off
    }
  #endif
  
  }
  

#!/usr/bin/env python

  import argparse
  import math
  import sys
  
  from PIL import Image
  
  
  def spherical_deform(img, out_height=None):
      # Idea here: We map rows from the source image onto rows in the destination
      # image so that the visual depiction of the image on a spherical display
      # will appear to be the same as if the display were planar.
      #
      # For a spherical display of 36 pixels in height, the real-world y-value
      # of the pixel location is sin(theta) where theta is the latitude of the
      # pixel. North pole has y-value of 1, equator of 0, and south pole of -1.
      #
      # For each row in the source image, we want to determine which pixel
      # (== which angle theta) it should map onto in the destination image. The
      # destination image is always 36 pixels high.
      #
      # For a source image y-value of y_s, the corresponding pixel latitude
      # is theta = arcsin(y_s). For y_s = 1, theta = pi/2 or 90 degrees.
      # For y_s = 0, theta = 0, and y_s = -1, theta = -pi/2.
      #
      # Therefore, we map each row of the source image onto the range (1, -1)
      # where y_s = 1 is the top row, and y_s = -1 is the bottom row. We then
      # calculate theta = arcsin(y_s) for each row of the source image, as above.
      # We then calculate the corresponding pixel position as pixel_num = theta / 36
      # (where theta ranges from pi/2 to -pi/2).
      #
      # Because a typical source image will have many more rows than we have pixels,
      # we can perform resampling to assign a final color to each pixel.
  
      (in_width, in_height) = img.size
      out_height = out_height or in_height
      out_width = (in_width / in_height) * out_height
      # We start by scaling only in the y-dimension, then we scale in the x.
      out_img = Image.new("RGB", (in_width, out_height))
      in_pixels = img.load()
      out_pixels = out_img.load()
  
      # Map from 0 .. in_height -> 1 .. -1
      slope = -2.0 / in_height
      offset = 1.0
      last_out_row = 0
  
      for in_row in range(in_height):
          in_row_scaled = slope * in_row + offset
          theta = math.asin(in_row_scaled)
          # pixel_num = (theta / out_height)
          # Map from pi/2 .. -pi/2 -> 0 .. out_height
          m = out_height / -math.pi
          b = out_height / 2
          target_row = math.floor((m * theta) + b)
          if in_row == in_height - 1:
              target_row = out_height - 1
          # print(f"Row {in_row} -> {target_row}")
          for out_row in range(last_out_row, target_row + 1):
              for x in range(in_width):
                  out_pixels[x, out_row] = in_pixels[x, in_row]
          last_out_row = target_row
      return out_img
  
  
  def process_image(
      infile, outfile, name, width, height, outimage=False, spherical=False
  ):
      img = Image.open(infile)
      img = img.convert("RGB")
      if spherical:
          img = spherical_deform(img)
      img = img.resize((width, height), resample=Image.NEAREST)
      if outimage:
          img.save(outfile)
          print(f"Saved scaled image to {outfile}")
          return
  
      pixels = list(img.getdata())
  
      with open(outfile, "w+") as outf:
          outf.write(
              f"// Generated by genheader.py --name {name} --width {width} "
              f"--height {height} {infile} {outfile}\n"
          )
          outf.write(f"#define IMAGE_COLUMNS_{name} {width}\n")
          outf.write(f"#define IMAGE_ROWS_{name} {height}\n")
          outf.write(f"const static uint8_t IMAGE_{name}[] = {{\n")
          for pixel in pixels:
              r, g, b = pixel
              outf.write(f"{b:#04x}, {g:#04x}, {r:#04x},\n")
          outf.write("};\n")
      print(f"Saved header to {outfile}")
  
  
  def main():
      parser = argparse.ArgumentParser()
      parser.add_argument("--name", type=str, required=True)
      parser.add_argument("--width", type=int, default=72)
      parser.add_argument("--height", type=int, default=36)
      parser.add_argument(
          "--outimage",
          action="store_true",
          help="Write output as image, rather than header",
      )
      parser.add_argument(
          "--spherical",
          action="store_true",
          help="Stretch image vertically to compensate for spherical projecton",
      )
      parser.add_argument("infile")
      parser.add_argument("outfile")
      args = parser.parse_args()
  
      process_image(
          args.infile,
          args.outfile,
          args.name,
          args.width,
          args.height,
          args.outimage,
          args.spherical,
      )
  
  
  if __name__ == "__main__":
      main()